package com.cloud.common.core.asserts;

import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.cloud.common.core.enums.ErrorCodeEnum;
import com.cloud.common.core.exception.ApiException;
import com.cloud.common.core.model.error.ErrorCode;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;

import java.util.Collection;
import java.util.Map;
import java.util.Objects;

/**
 * <p>
 * API 断言
 * </p>
 */
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class ApiAssert {

    /**
     * 判断俩对象必须相同，否则抛出异常
     *
     * @param errorCodeEnum
     * @param obj1
     * @param obj2
     */
    public static void equals(ErrorCodeEnum errorCodeEnum, Object obj1, Object obj2) {
        if (!Objects.equals(obj1, obj2)) {
            failure(errorCodeEnum);
        }
    }

    /**
     * 判断俩对象必须相同，否则抛出异常
     *
     * @param errorCode
     * @param obj1
     * @param obj2
     */
    public static void equals(ErrorCode errorCode, Object obj1, Object obj2) {
        if (!Objects.equals(obj1, obj2)) {
            failure(errorCode);
        }
    }

    /**
     * 判断俩对象必须不同，否则抛出异常
     *
     * @param errorCodeEnum
     * @param obj1
     * @param obj2
     */
    public static void notEquals(ErrorCodeEnum errorCodeEnum, Object obj1, Object obj2) {
        if (Objects.equals(obj1, obj2)) {
            failure(errorCodeEnum);
        }
    }

    /**
     * 判断俩对象必须不相同，否则抛出异常
     *
     * @param errorCode
     * @param obj1
     * @param obj2
     */
    public static void notEquals(ErrorCode errorCode, Object obj1, Object obj2) {
        if (Objects.equals(obj1, obj2)) {
            failure(errorCode);
        }
    }

    /**
     * 判断必须true，否则抛出异常
     *
     * @param errorCodeEnum
     * @param condition
     */
    public static void isTrue(ErrorCodeEnum errorCodeEnum, boolean condition) {
        if (!condition) {
            failure(errorCodeEnum);
        }
    }

    /**
     * 判断必须为true，否则抛出异常
     *
     * @param errorCode
     * @param condition
     */
    public static void isTrue(ErrorCode errorCode, boolean condition) {
        if (!condition) {
            failure(errorCode);
        }
    }

    /**
     * 判断必须false，否则抛出异常
     *
     * @param errorCodeEnum
     * @param condition
     */
    public static void isFalse(ErrorCodeEnum errorCodeEnum, boolean condition) {
        if (condition) {
            failure(errorCodeEnum);
        }
    }

    /**
     * 判断必须为false，否则抛出异常
     *
     * @param errorCode
     * @param condition
     */
    public static void isFalse(ErrorCode errorCode, boolean condition) {
        if (condition) {
            failure(errorCode);
        }
    }

    /**
     * 判断多个对象必须为空，否则抛出异常
     *
     * @param errorCodeEnum
     * @param conditions
     */
    public static void isNull(ErrorCodeEnum errorCodeEnum, Object... conditions) {
        if (ObjectUtils.isNotNull(conditions)) {
            failure(errorCodeEnum);
        }
    }

    /**
     * 判断多个对象必须为空，否则抛出异常
     *
     * @param errorCode
     * @param conditions
     */
    public static void isNull(ErrorCode errorCode, Object... conditions) {
        if (ObjectUtils.isNotNull(conditions)) {
            failure(errorCode);
        }
    }

    /**
     * 判断多个对象必须不为空，否则抛出异常
     *
     * @param errorCodeEnum
     * @param conditions
     */
    public static void notNull(ErrorCodeEnum errorCodeEnum, Object... conditions) {
        if (ObjectUtils.isNull(conditions)) {
            failure(errorCodeEnum);
        }
    }

    /**
     * 判断多个对象必须不为空，否则抛出异常
     *
     * @param errorCode
     * @param conditions
     */
    public static void notNull(ErrorCode errorCode, Object... conditions) {
        if (ObjectUtils.isNull(conditions)) {
            failure(errorCode);
        }
    }


    /**
     * 判断数组必须为空，否则抛出异常
     *
     * @param errorCodeEnum
     * @param collection
     */
    public static void isEmpty(ErrorCodeEnum errorCodeEnum, Collection<?> collection) {
        if (CollectionUtils.isNotEmpty(collection)) {
            failure(errorCodeEnum);
        }
    }


    /**
     * 判断数组必须为空，否则抛出异常
     *
     * @param errorCode
     * @param collection
     */
    public static void isEmpty(ErrorCode errorCode, Collection<?> collection) {
        if (CollectionUtils.isNotEmpty(collection)) {
            failure(errorCode);
        }
    }

    /**
     * 判断数组必须不为空，否则抛出异常
     *
     * @param errorCodeEnum
     * @param collection
     */
    public static void notEmpty(ErrorCodeEnum errorCodeEnum, Collection<?> collection) {
        if (CollectionUtils.isEmpty(collection)) {
            failure(errorCodeEnum);
        }
    }

    /**
     * 判断数组对象必须不为空，否则抛出异常
     *
     * @param errorCode
     * @param collection
     */
    public static void notEmpty(ErrorCode errorCode, Collection<?> collection) {
        if (CollectionUtils.isEmpty(collection)) {
            failure(errorCode);
        }
    }


    /**
     * 判断map必须为空，否则抛出异常
     *
     * @param errorCodeEnum
     * @param map
     */
    public static void isEmpty(ErrorCodeEnum errorCodeEnum, Map<?, ?> map) {
        if (CollectionUtils.isNotEmpty(map)) {
            failure(errorCodeEnum);
        }
    }

    /**
     * 判断map必须为空，否则抛出异常
     *
     * @param errorCode
     * @param map
     */
    public static void isEmpty(ErrorCode errorCode, Map<?, ?> map) {
        if (CollectionUtils.isNotEmpty(map)) {
            failure(errorCode);
        }
    }

    /**
     * 判断map必须不为空，否则抛出异常
     *
     * @param errorCodeEnum
     * @param map
     */
    public static void notEmpty(ErrorCodeEnum errorCodeEnum, Map<?, ?> map) {
        if (CollectionUtils.isEmpty(map)) {
            failure(errorCodeEnum);
        }
    }

    /**
     * 判断map必须不为空，否则抛出异常
     *
     * @param errorCode
     * @param map
     */
    public static void notEmpty(ErrorCode errorCode, Map<?, ?> map) {
        if (CollectionUtils.isEmpty(map)) {
            failure(errorCode);
        }
    }


    /**
     * 判断多个字符串必须为空，否则抛出异常
     *
     * @param errorCodeEnum
     * @param css
     */
    public static void isStrEmpty(ErrorCodeEnum errorCodeEnum, CharSequence... css) {
        if (StringUtils.isNoneEmpty(css)) {
            failure(errorCodeEnum);
        }
    }

    /**
     * 判断多个字符串必须为空，否则抛出异常
     *
     * @param errorCode
     * @param css
     */
    public static void isStrEmpty(ErrorCode errorCode, CharSequence... css) {
        if (StringUtils.isNoneEmpty(css)) {
            failure(errorCode);
        }
    }

    /**
     * 判断多个字符串必须为空，否则抛出异常
     *
     * @param errorCodeEnum
     * @param css
     */
    public static void notStrEmpty(ErrorCodeEnum errorCodeEnum, CharSequence... css) {
        if (StringUtils.isAllEmpty(css)) {
            failure(errorCodeEnum);
        }
    }

    /**
     * 判断多个字符串必须为空，否则抛出异常
     *
     * @param errorCode
     * @param css
     */
    public static void notStrEmpty(ErrorCode errorCode, CharSequence... css) {
        if (StringUtils.isAllEmpty(css)) {
            failure(errorCode);
        }
    }

    /**
     * 判断数组必须为空，否则抛出异常
     *
     * @param errorCodeEnum
     * @param array
     */
    public static void isEmpty(ErrorCodeEnum errorCodeEnum, Object[] array) {
        if (ObjectUtils.isNotEmpty(array)) {
            failure(errorCodeEnum);
        }
    }

    /**
     * 判断数组对象必须为空，否则抛出异常
     *
     * @param errorCode
     * @param array
     */
    public static void isEmpty(ErrorCode errorCode, Object[] array) {
        if (ObjectUtils.isNotEmpty(array)) {
            failure(errorCode);
        }
    }

    /**
     * 判断数组必须不为空，否则抛出异常
     *
     * @param errorCodeEnum
     * @param array
     */
    public static void notEmpty(ErrorCodeEnum errorCodeEnum, Object[] array) {
        if (ObjectUtils.isEmpty(array)) {
            failure(errorCodeEnum);
        }
    }

    /**
     * 判断数组对象必须不为空，否则抛出异常
     *
     * @param errorCode
     * @param array
     */
    public static void notEmpty(ErrorCode errorCode, Object[] array) {
        if (ObjectUtils.isEmpty(array)) {
            failure(errorCode);
        }
    }


    /**
     * 失败结果
     *
     * @param errorCodeEnum 异常错误码
     */
    public static void failure(ErrorCodeEnum errorCodeEnum) {
        throw new ApiException(errorCodeEnum);
    }

    /**
     * 失败结果
     *
     * @param errorCode 异常错误码
     */
    public static void failure(ErrorCode errorCode) {
        throw new ApiException(errorCode);
    }

    /**
     * 失败结果
     *
     * @param errorCodeEnum 异常错误码
     * @param cause         抛出异常
     */
    public static void failure(ErrorCodeEnum errorCodeEnum, Throwable cause) {
        throw new ApiException(errorCodeEnum, cause);
    }

    /**
     * 失败结果
     *
     * @param errorCode 异常错误码
     * @param cause     抛出异常
     */
    public static void failure(ErrorCode errorCode, Throwable cause) {
        throw new ApiException(errorCode, cause);
    }

}
